home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / dev / misc / LEDA_gene.lha / LEDA-3.1c-generic / incl / LEDA / slist.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-05  |  2.8 KB  |  93 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  slist.h
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. #ifndef LEDA_SLIST_H
  17. #define LEDA_SLIST_H
  18.  
  19. //------------------------------------------------------------------------------
  20. // slist<T>  simply linked lists
  21. //------------------------------------------------------------------------------
  22.  
  23.  
  24. #include <LEDA/impl/slist.h>
  25.  
  26.  
  27.  
  28. template <class type>
  29.  
  30. class _CLASSTYPE slist : public SLIST {
  31.  
  32. type X;
  33.  
  34. int  cmp_el(GenPtr x, GenPtr y) const
  35.                              { return compare(ACCESS(type,x),ACCESS(type,y));}
  36. void print_el(GenPtr& x,ostream& out) const { Print(ACCESS(type,x),out);  }
  37. void read_el(GenPtr& x,istream& in)         { Read(X,in); x = Copy(X); }
  38. void clear_el(GenPtr& x)              const { Clear(ACCESS(type,x)); }
  39. void copy_el(GenPtr& x)               const { x = Copy(ACCESS(type,x)); }
  40.  
  41. int  int_type() const { return INT_TYPE(type); }
  42.  
  43. public:
  44.  
  45. slink* push(type a)             { return SLIST::push(Copy(a)); }
  46. slink* append(type a)           { return SLIST::append(Copy(a)); }
  47. slink* insert(type a, slink* l) { return SLIST::insert(Copy(a),l); }
  48.  
  49. void conc(slist<type>& l)       { SLIST::conc((SLIST&)l); }
  50.  
  51. slink* read_iterator(type& x) const 
  52. { GenPtr y; 
  53.   slink* p=SLIST::read_iterator(y);
  54.   if (p) x = ACCESS(type,y); 
  55.   return p; }
  56.  
  57. bool current_element(type& x) const {GenPtr y; bool b=SLIST::current_element(y);
  58.                                      if (b) x = ACCESS(type,y); return b; }
  59. bool next_element(type& x) const { GenPtr y; bool b = SLIST::next_element(y);
  60.                                    if (b) x = ACCESS(type,y); return b; }
  61.  
  62. type head()             const { return ACCESS(type,SLIST::head() ); }
  63. type tail()             const { return ACCESS(type,SLIST::tail() ); }
  64.  
  65. type pop()                    { GenPtr x=SLIST::pop(); 
  66.                                 type   y=ACCESS(type,x); 
  67.                                 Clear(ACCESS(type,x)); 
  68.                                 return y; }
  69.  
  70. type contents(slink* l) const { return ACCESS(type,SLIST::contents(l)); }
  71. type inf(slink* l)      const { return ACCESS(type,SLIST::contents(l)); }
  72.  
  73. GenPtr forall_loop_test(GenPtr it, type& x) const
  74. { if (it) x = contents(slist_item(it));
  75.   return it;
  76.  }
  77.  
  78.    slist() { }
  79.    slist(const slist<type>& a) : SLIST((SLIST&)a) { }
  80.    slist(type a) : SLIST(Convert(a)) { }
  81.    ~slist() {}
  82.  
  83.    slist<type>& operator=(const slist<type>& a)
  84.            { SLIST::operator=(a);  return *this; }
  85.  
  86.    slink* operator+=(type x)  { return append(x); }
  87.    slink* operator&=(type x)  { return push(x); }
  88.    type& operator[](slink* l) { return ACCESS(type,SLIST::entry(l)); }
  89. };
  90.  
  91.  
  92. #endif
  93.